/**
 * Software License, Version 1.0
 * 
 * Copyright 2003 The Trustees of Indiana University.  All rights reserved.
 * 
 *
 *Redistribution and use in source and binary forms, with or without 
 *modification, are permitted provided that the following conditions are met:
 *
 *1) All redistributions of source code must retain the above copyright notice,
 * the list of authors in the original source code, this list of conditions and
 * the disclaimer listed in this license;
 *2) All redistributions in binary form must reproduce the above copyright 
 * notice, this list of conditions and the disclaimer listed in this license in
 * the documentation and/or other materials provided with the distribution;
 *3) Any documentation included with all redistributions must include the 
 * following acknowledgement:
 *
 *"This product includes software developed by the Community Grids Lab. For 
 * further information contact the Community Grids Lab at 
 * http://communitygrids.iu.edu/."
 *
 * Alternatively, this acknowledgement may appear in the software itself, and 
 * wherever such third-party acknowledgments normally appear.
 * 
 *4) The name Indiana University or Community Grids Lab or NaradaBrokering, 
 * shall not be used to endorse or promote products derived from this software 
 * without prior written permission from Indiana University.  For written 
 * permission, please contact the Advanced Research and Technology Institute 
 * ("ARTI") at 351 West 10th Street, Indianapolis, Indiana 46202.
 *5) Products derived from this software may not be called NaradaBrokering, 
 * nor may Indiana University or Community Grids Lab or NaradaBrokering appear
 * in their name, without prior written permission of ARTI.
 * 
 *
 * Indiana University provides no reassurances that the source code provided 
 * does not infringe the patent or any other intellectual property rights of 
 * any other entity.  Indiana University disclaims any liability to any 
 * recipient for claims brought by any other entity based on infringement of 
 * intellectual property rights or otherwise.  
 *
 *LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH NO 
 *WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA UNIVERSITY GIVES
 *NO WARRANTIES AND MAKES NO REPRESENTATION THAT SOFTWARE IS FREE OF 
 *INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS. 
 *INDIANA UNIVERSITY MAKES NO WARRANTIES THAT SOFTWARE IS FREE FROM "BUGS", 
 *"VIRUSES", "TROJAN HORSES", "TRAP DOORS", "WORMS", OR OTHER HARMFUL CODE.  
 *LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR 
 *ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION 
 *GENERATED USING SOFTWARE.
 */
/**
 * Software License, Version 1.0
 *
 * Copyright 2003 The Trustees of Indiana University.  All rights reserved.
 *
 *
 *Redistribution and use in source and binary forms, with or without
 *modification, are permitted provided that the following conditions are met:
 *
 *1) All redistributions of source code must retain the above copyright notice,
 * the list of authors in the original source code, this list of conditions and
 * the disclaimer listed in this license;
 *2) All redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the disclaimer listed in this license in
 * the documentation and/or other materials provided with the distribution;
 *3) Any documentation included with all redistributions must include the
 * following acknowledgement:
 *
 *"This product includes software developed by the Community Grids Lab. For
 * further information contact the Community Grids Lab at
 * http://communitygrids.iu.edu/."
 *
 * Alternatively, this acknowledgement may appear in the software itself, and
 * wherever such third-party acknowledgments normally appear.
 *
 *4) The name Indiana University or Community Grids Lab or NaradaBrokering,
 * shall not be used to endorse or promote products derived from this software
 * without prior written permission from Indiana University.  For written
 * permission, please contact the Advanced Research and Technology Institute
 * ("ARTI") at 351 West 10th Street, Indianapolis, Indiana 46202.
 *5) Products derived from this software may not be called NaradaBrokering,
 * nor may Indiana University or Community Grids Lab or NaradaBrokering appear
 * in their name, without prior written permission of ARTI.
 *
 *
 * Indiana University provides no reassurances that the source code provided
 * does not infringe the patent or any other intellectual property rights of
 * any other entity.  Indiana University disclaims any liability to any
 * recipient for claims brought by any other entity based on infringement of
 * intellectual property rights or otherwise.
 *
 *LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH NO
 *WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA UNIVERSITY GIVES
 *NO WARRANTIES AND MAKES NO REPRESENTATION THAT SOFTWARE IS FREE OF
 *INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS.
 *INDIANA UNIVERSITY MAKES NO WARRANTIES THAT SOFTWARE IS FREE FROM "BUGS",
 *"VIRUSES", "TROJAN HORSES", "TRAP DOORS", "WORMS", OR OTHER HARMFUL CODE.
 *LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR
 *ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION
 *GENERATED USING SOFTWARE.
 */

package cgl.narada.transport.udp;

import java.util.Vector;

/**
 * <p>Title: UDPPackageDivide </p>
 * <p>Description: Devides a big package to a small packages so that they can
 * be sent easily</p>
 * @author Beytullah Yildiz
 * @version 1.0
 */

public class UDPPackageDivide {

  private long lastuniquenumber;

  public UDPPackageDivide() {
  }

  /**
   * returns the number of partition and partition sizes
   * @param sizearray the whole array for dividing
   * @param sizeofdata the array size
   */

  private void getPartitonSizes(int[] sizearray, int sizeofdata) {

    int approxpacksize = 1024 * 60;
    int remainpacksize = sizeofdata;
    int numberofpack = 0;

    while (true) {

      if (remainpacksize < approxpacksize) {
        break;
      }
      else {
        remainpacksize = remainpacksize - approxpacksize;
        numberofpack++;
      }

    }

    sizearray[0] = numberofpack; // number of approximately calculated packages
    sizearray[1] = approxpacksize; // the size of approximately calculated packages
    sizearray[2] = remainpacksize; // remaining pack size

  }

  /**
   * Creates a vector which consists small parts of big chunk of bytes
   * @param ovec the vector which will consist the small parts
   * @param wholepack the whole bytes
   */

  public void addJobsToJobVector(Vector ovec, byte[] wholepack, long pnumber) {
    int[] sizearray = new int[3];
    int datalength = wholepack.length;
    getPartitonSizes(sizearray, datalength);

    int poffset = 0;
    int endpoint = 0;

    int i = 0;
    for (i = 0; i < sizearray[0]; i++) {
      endpoint = poffset + sizearray[1];
      PackageObject pob = new PackageObject(wholepack, pnumber, datalength,
                                            poffset, endpoint);

      synchronized (ovec) {
        ovec.add(pob);
      }
      poffset = endpoint;

    }

    if (sizearray[2] > 0) {
      endpoint = poffset + sizearray[2];
      PackageObject pob = new PackageObject(wholepack, pnumber, datalength,
                                            poffset, endpoint);

      synchronized (ovec) {
        ovec.add(pob);
      }
    }
  }

  public static void main(String[] args) {
    UDPPackageDivide UDPPackageHandler1 = new
        UDPPackageDivide();
  }
  /**
   *
   * <p>Title: PackageObject</p>
   * <p>Description: An in ternal class to handle the small packages</p>
   * @author not attributable
   * @version 1.0
   */

   public class PackageObject {

     private long uniquenumber;
     private byte[] sendingbytes;
     private int offset;
     private int startpoint;
     private int endpoint;
     private int wholepacksize;

     private long time;

     public PackageObject() {
     }

     public PackageObject(byte[] pack, long unumber, int wholesize, int sp,
                          int ep) {
       sendingbytes = pack;
       uniquenumber = unumber;
       wholepacksize = wholesize;
       startpoint = sp;
       endpoint = ep;

     }

     public void setSendingBytes(byte[] sarray) {

       sendingbytes = sarray;
     }

     public byte[] getSendingBytes() {

       return sendingbytes;
     }

     public void setWholePackSize(int psize) {

       wholepacksize = psize;
     }

     public int getWholePackSize() {

       return wholepacksize;
     }

     public void setOffset(int off) {
       offset = off;
     }

     public int getOffset() {

       return offset;

     }

     public long getUniqueNumber() {
       return uniquenumber;

     }

     public int getStartPoint() {
       return startpoint;
     }

     public int getEndPoint() {
       return endpoint;
     }

     public void setTime(long t) {
       time = t;
     }

     public long getTime() {
       return time;
     }

   }

}